﻿#define _CRT_SECURE_NO_WARNINGS

//#include<iostream>
//using namespace std;
//
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	bool operator<(const Date& d)
//	{
//		if (_year < d._year)
//		{
//			return true;
//		}
//		else if (_year == d._year
//			&& _month < d._month)
//		{
//			return true;
//		}
//		else if (_year == d._year
//			&& _month == d._month
//			&& _day < d._day)
//		{
//			return true;
//		}
//
//		return false;
//	}
//
//	//前置++
//	Date operator++()
//	{
//		*this += 1;
//		return *this;
//	}
//
//	//后置++
//	Date operator++(int)
//	{
//		Date tmp(*this);
//
//		*this += 1;
//
//		return tmp;
//	}
//
//
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main()
//{
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}

	//Date& operator=(const Date& d)
	//{
	//	//自我赋值
	//	if (this == &d)
	//	{
	//		return *this;
	//	}

	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;

	//	return *this;
	//}

//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1(2025, 5, 9);
//	Date d2 = d1; //拷贝构造
//	d2.Print();
//	Date d3;
//	d3 = d1; //赋值拷贝
//	d3.Print();
//
//	return 0;
//}

#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
	//构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	//拷贝构造函数
	Stack(const Stack& st)
	{
		// 需要对_a指向资源创建同样⼤的资源再拷⻉值 
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	//入栈函数
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *

				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}

	//赋值重载函数
	Stack& operator=(const Stack& st)
	{
		//先释放左操作数栈的指向的空间
		free(_a);
		//在开辟和右操作数栈的指向的空间大小一样的空间给左操作数的栈
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail\n");
			exit(-1);
		}

		memcpy(_a, st._a, sizeof(int) * st._capacity);
		_top = st._top;
		_capacity = st._capacity;

		return *this;
	}

	//析构函数
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);

	Stack st2;
	st2.Push(10);
	st2.Push(20);
	st2.Push(30);
	st2.Push(40);

	st2 = st2;

	return 0;
}

